#include <iostream>

/**
 * Implicit（隐式）转换：
 *      自动发生
 *      可能导致意外行为
 *      代码意图不明确
 *      更容易出错
 *  Explicit（显式）转换：
 *      需要明确指出
 *      防止意外转换
 *      代码意图清晰
 *      更安全
 *  使用建议：
 *      默认使用 explicit
 *      只在确实需要隐式转换时才省略 explicit
 *      特别是对于：
 *      单参数构造函数
 *      类型转换运算符
 *      可能引起混淆的转换
 */

class Coffee
{
public:
    // 隐式构造函数（默认）
    Coffee(int temperature)
    {
        // 用温度创建咖啡
    }
};

// 咖啡店场景
void serveCoffee(Coffee coffee)
{
    // 服务咖啡
}

void serveAcoffee()
{
    // 顾客说 给我一杯咖啡
    // 这就像你说"给我85度的"，服务员自动理解你要的是85度的咖啡。
    serveCoffee(85); // 隐式转换 直接用温度创建咖啡
}

class CoffeeLucky
{
public:
    // 显式构造函数（默认）
    explicit CoffeeLucky(int temperature)
    {
        // 用温度创建咖啡
    }
};

void serveLuckyCoffee(CoffeeLucky coffee)
{
    // 服务咖啡
}

void serveALuckycoffee()
{
    // 顾客说 给我一杯咖啡
    // 这就像你说"给我85度的"，服务员自动理解你要的是85度的咖啡。
    // serveLuckyCoffee(85); // 回报错
    serveLuckyCoffee(CoffeeLucky(85));
}

class String
{
public:
    // 隐式构造函数
    String(int length)
    {
        // 创建指定长度的字符串
    }
};

void processString(String str) {}

// 改成显式后：
class BetterString
{
public:
    explicit BetterString(int length)
    {
        // 创建指定长度的字符串
    }
};

void processBetterString(BetterString str) {}

int main()
{
    // 使用场景
    processString(10); // 编译通过，但可能不是你想要的！
                       // 创建了长度为10的空字符串

    // processBetterString(10);               // 编译错误！
    processBetterString(BetterString(10)); // 正确：明确表示要创建字符串
}
